并发编程学习总结(四) ：java 显式锁ReentrantLock使用详解之lock()\unlock() 加锁与释放锁

在大多数实际的多线程应用中，两个或两个以上的线程需要共享对同一数据的存取。如果两个线程存取相同的对象，并且每一个线程都调用了一个修改该对象状态的方法，那么线程彼此踩了对方的脚，根据各线程访问数据的次序，可能会产生讹误的对象。这样的一种现象称之为竞争条件。

当然多个线程共享一个变量在实际的应用中有时难以避免，但是我们可以通过java提供的一些技术来避免线程彼此踩脚的行为发生。

java提供了锁机制来对多个线程共享一个变量进行同步，在java SE 5.0引入了显式锁ReentrantLock类，以及从1.0版本开始的对象内部锁 可以通过synchronized关键字声明某个线程持有这个对象内部锁，我们这小结先学习ReentrantLock锁的使用，下一节学习synchronized关键字的使用。

(1) ReentrantLock锁的使用结构

ReentrantLock 是java.unti.concurrent包下的一个类，它的一般使用结构如下所示：

public void lockMethod() {
	ReentrantLock myLock = new ReentrantLock();
	myLock.lock();
	try{
		// 受保护的代码段
		//critical section
	} finally {
		// 可以保证发生异常 锁可以得到释放 避免死锁的发生
		myLock.unlock();
	}
}

把解锁操作括在finally字句之内是至关重要的，如果受保护的代码抛出异常，锁可以得到释放，这样可以避免死锁的发生

我们执行下面代码：

public class ReentrantLockTest1 {
	
	private int num = 10;
    private ReentrantLock myLock = new ReentrantLock();
	public void writeNumMethod() {	
		//myLock.lock();
		try{
			// 受保护的代码段
			int index =10;
			while(index > 0) {
				System.out.println(Thread.currentThread().getName() + " : "+ num);
				num-=10;
				long beginTime = System.currentTimeMillis();
				while(System.currentTimeMillis() - beginTime < 10){}
				num+=10;
				System.out.println(Thread.currentThread().getName() + " : "+ num);
				index--;
			}

	} finally {
			// 可以保证发生异常 锁可以得到释放 避免死锁的发生
			//myLock.unlock();
		}
	}
	
	public void readNumMethod() {	
		//myLock.lock();
		try{
			int index = 10;
			// 受保护的代码段
			while(index > 0) {
				System.out.println(Thread.currentThread().getName() + " : "+ num);
				index--;
			}

	} finally {
			// 可以保证发生异常 锁可以得到释放 避免死锁的发生
			//myLock.unlock();
		}
	}
	
	
	public static void main(String [] args) {
		final ReentrantLockTest1 myLockTest = new ReentrantLockTest1();
		
		Thread t1 = new Thread(new Runnable() {
			public void run() {
				myLockTest.writeNumMethod();
			}
		},"A");
		
		Thread t2 = new Thread(new Runnable() {
			public void run() {
				myLockTest.readNumMethod();
			}
		},"B");
		
		t1.start();
		t2.start();
	}
}

上面示例中 writeNumMethod方法 对num变量进行先减10 然后再加10，readNumMethod方法读取num的值，线程A执行writeNumMethod方法，线程B执行readNumMethos方法，我们期望两个线程的 输出的结果都是10，但是由于我们没有对这个共享变量num 进行同步，假如此时线程A执行到num-=10这句代码时，线程的cpu时间片到时了，这时操作系统就会去调度线程B这样线程B就会输出0值。我们看一输出结果。

输出结果：

A : 10
B : 10
B : 0
B : 0
B : 0
B : 0
B : 0
B : 0
B : 0
B : 0
B : 0
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10

果然共享变量出现了讹误的现象。

那么如果我们取消代码中显式锁前的注释，再次运行代码。

A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
A : 10
B : 10
B : 10
B : 10
B : 10
B : 10
B : 10
B : 10
B : 10
B : 10
B : 10

输出结果是显式锁很好的保护了 writeNumMethod 的操作，假设线程A在执行结束前被剥夺了运行权，这是线程B调用readNumMethod方法去读取num的值，但是由于线程B不能获得锁，线程B必须等待线程A释放锁才能执行readNumMethod方法。这样就保证了writeNumMethod方法的原子性，也就保证了共享变量num不会出现讹误的现象。

(2)ReentrantLock是可重入锁

ReentrantLock持有一个所计数器，当已持有所的线程再次获得该锁时计数器值加1，每调用一次lock.unlock()时所计数器值减一，直到所计数器值为0，此时线程释放锁。

我们测试以下代码：

public class ReentrantLockTest2 {
	
	private ReentrantLock lock = new ReentrantLock();
	
	public void testReentrantLock() {
		// 线程获得锁
		lock.lock();
		try {
			System.out.println(Thread.currentThread().getName() + " get lock");
			long beginTime = System.currentTimeMillis();
			while(System.currentTimeMillis() - beginTime < 100){}
			lock.lock();
			try {
				System.out.println(Thread.currentThread().getName() + " get lock again");
				long beginTime2 = System.currentTimeMillis();
				while(System.currentTimeMillis() - beginTime2 < 100){}
			}finally {
				// 线程释放锁
				lock.unlock();
				System.out.println(Thread.currentThread().getName() + " release lock");
			}
		} finally {
			// 线程释放锁
			lock.unlock();
			System.out.println(Thread.currentThread().getName() + " release lock again");
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		final ReentrantLockTest2 test2 = new ReentrantLockTest2();
		Thread thread = new Thread(new Runnable(){
			public void run() {
				test2.testReentrantLock();
			}
		},"A");
		thread.start();
	}

}

输出结果：
A get lock
A get lock again
A release lock
A release lock again